home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_0399 / 73 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  13.1 KB
  1. Date: Tue, 2 Feb 93 17:20:57 PST
  2. From: hyc@hanauma.Jpl.Nasa.Gov (Howard Chu)
  3. Message-Id: <9302030120.AA03046@hanauma.JPL.NASA.GOV>
  4. To: mint@terminator.rs.itd.umich.edu
  5. Subject: Fasttext patches
  6.  
  7. I got some pretty good speedups by avoiding a lot of invocations of the
  8. gotoxy code in the really simple cases... Also, despite the fact that the
  9. tab processing looks gross, it actually is faster and more compact than
  10. the equivalent gotoxy compilation. I last sent this code out for mint 0.96,
  11. but it didn't seem to make it into .97 or .98... (Oh, and there was a typo
  12. in the stuff I sent out for 0.96 causing it to work incorrectly on color
  13. resolutions. It's fixed in this patch.)
  14.  
  15. I also changed paint16m to paint816m, because I like to use the 8 row high
  16. font in monochrome to get twice as many text lines per screen. Unfortunately
  17. you can't do hardware scrolling if you do this. (Perhaps, since the output
  18. might already be buffered, the code could scroll two lines at a time then? I
  19. haven't investigated that route...)
  20.  
  21. *** fasttext.c    Wed Dec 23 12:44:06 1992
  22. --- ../src/fasttext.c    Tue Feb  2 17:16:51 1993
  23. ***************
  24. *** 24,28 ****
  25.   static void paint P_((SCREEN *, int, char *)),
  26.        paint8c P_((SCREEN *, int, char *)),
  27. !      paint16m P_((SCREEN *, int, char *));
  28.   
  29.   INLINE static void curs_off P_((SCREEN *)), curs_on P_((SCREEN *));
  30. --- 24,28 ----
  31.   static void paint P_((SCREEN *, int, char *)),
  32.        paint8c P_((SCREEN *, int, char *)),
  33. !      paint816m P_((SCREEN *, int, char *));
  34.   
  35.   INLINE static void curs_off P_((SCREEN *)), curs_on P_((SCREEN *));
  36. ***************
  37. *** 51,54 ****
  38. --- 51,55 ----
  39.   static short hardline;
  40.   static void (*vpaint) P_((SCREEN *, int, char *));
  41. + static char *rowoff;
  42.   
  43.   void init P_((void));
  44. ***************
  45. *** 137,140 ****
  46. --- 138,142 ----
  47.       char *data, *foo;
  48.       static char chardata[256*16];
  49. +     register int linelen;
  50.   
  51.       foo = lineA0();
  52. ***************
  53. *** 145,149 ****
  54.          Erling
  55.       */
  56. !     scrnsize = (v->maxy+1)*(long)v->linelen;
  57.       if (hardscroll == -1) {
  58.       /* request for auto-setting */
  59. --- 147,162 ----
  60.          Erling
  61.       */
  62. !     linelen = v->linelen;
  63. !     scrnsize = (v->maxy+1)*(long)linelen;
  64. !     rowoff = (char *)kmalloc((long)((v->maxy+1) * sizeof(long)));
  65. !     if (rowoff == 0) {
  66. !         FATAL("Insufficient memory for screen offset table!");
  67. !     } else {
  68. !         long off, *lptr = (long *)rowoff;
  69. !         for (i=0, off=0; i<=v->maxy; i++) {
  70. !             *lptr++ = off;
  71. !             off += linelen;
  72. !         }
  73. !     }
  74.       if (hardscroll == -1) {
  75.       /* request for auto-setting */
  76. ***************
  77. *** 177,187 ****
  78.               }
  79.           }
  80. !     } else if (v->cheight == 16 && v->planes == 1) {
  81.           foo = &chardata[0];
  82. !         vpaint = paint16m;
  83.           for (i = 0; i < 256; i++) {
  84.               chartab[i] = foo;
  85.               data = v->fontdata + i;
  86. !             for (j = 0; j < 16; j++) {
  87.                   *foo++ = *data;
  88.                   data += v->form_width;
  89. --- 190,200 ----
  90.               }
  91.           }
  92. !     } else if ((v->cheight == 16 || v->cheight == 8) && v->planes == 1) {
  93.           foo = &chardata[0];
  94. !         vpaint = paint816m;
  95.           for (i = 0; i < 256; i++) {
  96.               chartab[i] = foo;
  97.               data = v->fontdata + i;
  98. !             for (j = 0; j < v->cheight; j++) {
  99.                   *foo++ = *data;
  100.                   data += v->form_width;
  101. ***************
  102. *** 231,242 ****
  103.       if (y == v->maxy)
  104.           place += scrnsize - v->linelen;
  105. !     else if (y) /* Yo, the screen might be bigger than 32767 bytes...
  106. !                Do a cast to long.    Erling. */
  107. !         place += (long)y * v->linelen;
  108. ! 
  109. !     if ((j = v->planes) > 1) {
  110.           i = (x & 0xfffe);
  111. !         while (--j > 0)
  112. !             place += i;
  113.       }
  114.       return place;
  115. --- 244,256 ----
  116.       if (y == v->maxy)
  117.           place += scrnsize - v->linelen;
  118. !     else if (y) {
  119. !         y+=y;    /* Make Y into index for longword array. */
  120. !         y+=y;    /* Two word-size adds are faster than a 2-bit shift. */
  121. !         place += *(long *)(rowoff + y);
  122. !     }
  123. !     if ((j = v->planes-1)) {
  124.           i = (x & 0xfffe);
  125. !         do place += i;
  126. !         while (--j);
  127.       }
  128.       return place;
  129. ***************
  130. *** 246,251 ****
  131.    * paint(v, c, place): put character 'c' at position 'place' on screen
  132.    * v. It is assumed that x, y are proper coordinates!
  133. !  * Specialized versions (paint8c and paint16m) of this routine follow;
  134. !  * they assume 8 line high characters, medium res. and 16 line/mono,
  135.    * respectively.
  136.    */
  137. --- 260,265 ----
  138.    * paint(v, c, place): put character 'c' at position 'place' on screen
  139.    * v. It is assumed that x, y are proper coordinates!
  140. !  * Specialized versions (paint8c and paint816m) of this routine follow;
  141. !  * they assume 8 line high characters, medium res. and 8 or 16 line/mono,
  142.    * respectively.
  143.    */
  144. ***************
  145. *** 398,402 ****
  146.   
  147.   static void
  148. ! paint16m(v, c, place)
  149.       SCREEN *v;
  150.       int c;
  151. --- 412,416 ----
  152.   
  153.   static void
  154. ! paint816m(v, c, place)
  155.       SCREEN *v;
  156.       int c;
  157. ***************
  158. *** 431,434 ****
  159. --- 445,450 ----
  160.           place += vplanesiz;
  161.           *place = d;
  162. +         if (v->cheight == 8)
  163. +         return;
  164.           place += vplanesiz;
  165.           *place = d;
  166. ***************
  167. *** 487,490 ****
  168. --- 503,510 ----
  169.           d = *data++;
  170.           *place = d;
  171. + 
  172. +         if (v->cheight == 8)
  173. +             return;
  174. + 
  175.           place += vplanesiz;
  176.   
  177. ***************
  178. *** 566,569 ****
  179. --- 586,593 ----
  180.           d = ~*data++;
  181.           *place = d;
  182. + 
  183. +         if (v->cheight == 8)
  184. +             return;
  185. + 
  186.           place += vplanesiz;
  187.   
  188. ***************
  189. *** 644,648 ****
  190.       /* Hey, again the screen might be bigger than 32767 bytes.
  191.          Do another cast... */
  192. !     dst = (int *)(base + ((long)r * v->linelen));
  193.       if (v->bgcol == 0)
  194.         zero((char *)dst, v->linelen);
  195. --- 668,674 ----
  196.       /* Hey, again the screen might be bigger than 32767 bytes.
  197.          Do another cast... */
  198. !     r += r;
  199. !     r += r;
  200. !     dst = (int *)(base + *(long *)(rowoff+r));
  201.       if (v->bgcol == 0)
  202.         zero((char *)dst, v->linelen);
  203. ***************
  204. *** 748,761 ****
  205.       if (hardline < hardscroll) { /* just move the screen */
  206.           base += v->linelen;
  207. !         v->cursaddr = PLACE(v, v->cx, v->cy);
  208. !         Setscreen(base, base, -1);
  209. !     }
  210. !     else {
  211.           hardline = 0;
  212.           quickmove(hardbase, base + v->linelen, scrnsize - v->linelen);
  213.           base = hardbase;
  214. -         v->cursaddr = PLACE(v, v->cx, v->cy);
  215. -         Setscreen(hardbase, hardbase, -1);
  216.       }
  217.   }
  218.   
  219. --- 774,784 ----
  220.       if (hardline < hardscroll) { /* just move the screen */
  221.           base += v->linelen;
  222. !     } else {
  223.           hardline = 0;
  224.           quickmove(hardbase, base + v->linelen, scrnsize - v->linelen);
  225.           base = hardbase;
  226.       }
  227. +     v->cursaddr = PLACE(v, v->cx, v->cy);
  228. +     Setscreen(base, base, -1);
  229.   }
  230.   
  231. ***************
  232. *** 781,787 ****
  233.           }
  234.           nbytes = scrnsize - v->linelen;
  235.       }
  236. -     else
  237. -         nbytes = (long)v->linelen * (v->maxy - r);
  238.   
  239.       /* Sheeze, how many times do we really have to cast... 
  240. --- 804,813 ----
  241.           }
  242.           nbytes = scrnsize - v->linelen;
  243. +     } else {
  244. +         register int i = v->maxy - r;
  245. +         i += i;
  246. +         i += i;
  247. +         nbytes = *(long *)(rowoff+i);
  248.       }
  249.   
  250.       /* Sheeze, how many times do we really have to cast... 
  251. ***************
  252. *** 789,793 ****
  253.       */
  254.   
  255. !     dst = (long *)(base + ((long)r * v->linelen));
  256.       src = (long *)( ((long)dst) + v->linelen);
  257.   
  258. --- 815,821 ----
  259.       */
  260.   
  261. !     r += r;
  262. !     r += r;
  263. !     dst = (long *)(base + *(long *)(rowoff + r));
  264.       src = (long *)( ((long)dst) + v->linelen);
  265.   
  266. ***************
  267. *** 809,823 ****
  268.   {
  269.       long *src, *dst;
  270. !     int i, limit;
  271.   
  272. !     limit = v->maxy;
  273. !     for (i = limit-1; i >= r ; --i) {
  274.       /* move line i to line i+1 */
  275. !     /* AND do some casting to support big screens.
  276. !        Erling
  277. !     */
  278. !         src = (long *)(base + ((long)i * v->linelen));
  279. !         dst = (long *)(base + ((i+1)*(long)v->linelen));
  280. !         quickmove(dst, src, v->linelen);
  281.       }
  282.   
  283. --- 837,855 ----
  284.   {
  285.       long *src, *dst;
  286. !     int i, j, linelen;
  287.   
  288. !     i = v->maxy - 1;
  289. !     i += i;
  290. !     i += i;
  291. !     j = r+r;
  292. !     j += j;
  293. !     linelen = v->linelen;
  294. !     src = (long *)(base + *(long *)(rowoff + i));
  295. !     dst = (long *)((long)src + linelen);
  296. !     for (; i >= j ; i -= 4) {
  297.       /* move line i to line i+1 */
  298. !         quickmove(dst, src, linelen);
  299. !         dst = src;
  300. !         src = (long *)((long) src - linelen);
  301.       }
  302.   
  303. ***************
  304. *** 864,887 ****
  305.       (*vpaint)(v, c, v->cursaddr);
  306.       state = normal_putch;
  307. -     v->cx++;
  308. -     if (v->cx > v->maxx) {
  309. -         if (v->flags & FWRAP) {
  310. -             v->cx = 0;
  311. -             normal_putch(v, '\n');
  312. -             v->cursaddr = PLACE(v, v->cx, v->cy);
  313. -         } else {
  314. -             v->cx = v->maxx;
  315. -         }
  316. -     } else {
  317. - #if 0
  318. -         v->cursaddr = PLACE(v, v->cx, v->cy);
  319. - #else
  320. -         v->cursaddr++;
  321. -         if ( (v->cx & 1) == 0 && v->planes > 1) { /* new word */
  322. -             short skipwords = v->planes - 1;
  323. -             v->cursaddr += skipwords+skipwords;
  324. -         }
  325. - #endif
  326. -     }
  327.   }
  328.   
  329. --- 896,899 ----
  330. ***************
  331. *** 895,898 ****
  332. --- 907,911 ----
  333.       int c;
  334.   {
  335. +     int i;
  336.       int cx, cy;
  337.   
  338. ***************
  339. *** 901,914 ****
  340.       switch (c) {
  341.       case 'A':        /* cursor up */
  342. !         gotoxy(v, cx, cy-1);
  343.           break;
  344.       case 'B':        /* cursor down */
  345. !         gotoxy(v, cx, cy+1);
  346.           break;
  347.       case 'C':        /* cursor right */
  348. !         gotoxy(v, cx+1, cy);
  349.           break;
  350.       case 'D':        /* cursor left */
  351. !         gotoxy(v, cx-1, cy);
  352.           break;
  353.       case 'E':        /* clear home */
  354. --- 914,943 ----
  355.       switch (c) {
  356.       case 'A':        /* cursor up */
  357. !         if (cy) {
  358. ! moveup:            v->cy = --cy;
  359. !             v->cursaddr -= v->linelen;
  360. !         }
  361.           break;
  362.       case 'B':        /* cursor down */
  363. !         if (cy < v->maxy) {
  364. !             v->cy = ++cy;
  365. !             v->cursaddr += v->linelen;
  366. !         }
  367.           break;
  368.       case 'C':        /* cursor right */
  369. !         if (cx < v->maxx) {
  370. !             if ((i = v->planes-1) && (cx & 1))
  371. !                 v->cursaddr += i + i;
  372. !             v->cx = ++cx;
  373. !             v->cursaddr++;
  374. !         }
  375.           break;
  376.       case 'D':        /* cursor left */
  377. !         if (cx) {
  378. !             v->cx = --cx;
  379. !             v->cursaddr--;
  380. !             if ((i = v->planes-1) && (cx & 1))
  381. !                 v->cursaddr -= i + i;
  382. !         }
  383.           break;
  384.       case 'E':        /* clear home */
  385. ***************
  386. *** 916,920 ****
  387.           /* fall through... */
  388.       case 'H':        /* cursor home */
  389. !         gotoxy(v, 0, 0);
  390.           break;
  391.       case 'I':        /* cursor up, insert line */
  392. --- 945,950 ----
  393.           /* fall through... */
  394.       case 'H':        /* cursor home */
  395. !         v->cx = 0; v->cy = 0;
  396. !         v->cursaddr = base;
  397.           break;
  398.       case 'I':        /* cursor up, insert line */
  399. ***************
  400. *** 923,927 ****
  401.           }
  402.           else
  403. !             gotoxy(v, cx, cy-1);
  404.           break;
  405.       case 'J':        /* clear below cursor */
  406. --- 953,957 ----
  407.           }
  408.           else
  409. !             goto moveup;
  410.           break;
  411.       case 'J':        /* clear below cursor */
  412. ***************
  413. *** 932,940 ****
  414.           break;
  415.       case 'L':        /* insert a line */
  416. !         gotoxy(v, 0, cy);
  417.           insert_line(v, cy);
  418.           break;
  419.       case 'M':        /* delete line */
  420. !         gotoxy(v, 0, cy);
  421.           delete_line(v, cy);
  422.           break;
  423. --- 962,976 ----
  424.           break;
  425.       case 'L':        /* insert a line */
  426. !         v->cx = 0;
  427. !         i = cy + cy;
  428. !         i += i;
  429. !         v->cursaddr = base + *(long *)(rowoff + i);
  430.           insert_line(v, cy);
  431.           break;
  432.       case 'M':        /* delete line */
  433. !         v->cx = 0;
  434. !         i = cy + cy;
  435. !         i += i;
  436. !         v->cursaddr = base + *(long *)(rowoff + i);
  437.           delete_line(v, cy);
  438.           break;
  439. ***************
  440. *** 971,975 ****
  441.           break;
  442.       case 'l':        /* clear line */
  443. !         gotoxy(v, 0, cy);
  444.           clrline(v, cy);
  445.           break;
  446. --- 1007,1014 ----
  447.           break;
  448.       case 'l':        /* clear line */
  449. !         v->cx = 0;
  450. !         i = cy + cy;
  451. !         i += i;
  452. !         v->cursaddr = base + *(long *)(rowoff + i);
  453.           clrline(v, cy);
  454.           break;
  455. ***************
  456. *** 1028,1031 ****
  457. --- 1067,1072 ----
  458.       int c;
  459.   {
  460. +     register int i;
  461. + 
  462.   /* control characters */
  463.       if (c < ' ') {
  464. ***************
  465. *** 1032,1036 ****
  466.           switch (c) {
  467.           case '\r':
  468. !             gotoxy(v, 0, v->cy);
  469.               return;
  470.           case '\n':
  471. --- 1073,1080 ----
  472.           switch (c) {
  473.           case '\r':
  474. ! col0:            v->cx = 0;
  475. !             i = v->cy + v->cy;
  476. !             i += i;
  477. !             v->cursaddr = base + *(long *)(rowoff + i);
  478.               return;
  479.           case '\n':
  480. ***************
  481. *** 1037,1046 ****
  482.               if (v->cy == v->maxy) {
  483.                   scroll(v);
  484.               }
  485. -             else
  486. -                 gotoxy(v, v->cx, v->cy+1);
  487.               return;
  488.           case '\b':
  489. !             gotoxy(v, v->cx-1, v->cy);
  490.               return;
  491.           case '\007':        /* BELL */
  492. --- 1081,1096 ----
  493.               if (v->cy == v->maxy) {
  494.                   scroll(v);
  495. +             } else {
  496. +                 v->cy++;
  497. +                 v->cursaddr += v->linelen;
  498.               }
  499.               return;
  500.           case '\b':
  501. !             if (v->cx) {
  502. !                 v->cx--;
  503. !                 v->cursaddr--;
  504. !                 if ((i = v->planes-1) && (v->cx & 1))
  505. !                     v->cursaddr -= i+i;
  506. !             }
  507.               return;
  508.           case '\007':        /* BELL */
  509. ***************
  510. *** 1051,1055 ****
  511.               return;
  512.           case '\t':
  513. !             gotoxy(v, (v->cx + 8) & ~7, v->cy);
  514.               return;
  515.           default:
  516. --- 1101,1124 ----
  517.               return;
  518.           case '\t':
  519. !             if (v->cx < v->maxx) {
  520. !                 register union {
  521. !                     long l;
  522. !                     short i[2];
  523. !                 } j;
  524. !                 j.l = 0;
  525. !                 j.i[1] = 8 - (v->cx & 7);
  526. !                 v->cx += j.i[1];
  527. !                 if (v->cx - v->maxx > 0) {
  528. !                     j.i[1] = v->cx - v->maxx;
  529. !                     v->cx = v->maxx;
  530. !                 }
  531. !                 v->cursaddr += j.l;
  532. !                 if ((i = v->planes-1)) {
  533. !                     if (j.l & 1)
  534. !                         j.i[1]++;
  535. !                     do v->cursaddr += j.l;
  536. !                     while (--i);
  537. !                 }
  538. !             }
  539.               return;
  540.           default:
  541. ***************
  542. *** 1062,1068 ****
  543.       if (v->cx > v->maxx) {
  544.           if (v->flags & FWRAP) {
  545. -             v->cx = 0;
  546.               normal_putch(v, '\n');
  547. !             v->cursaddr = PLACE(v, v->cx, v->cy);
  548.           } else {
  549.               v->cx = v->maxx;
  550. --- 1131,1136 ----
  551.       if (v->cx > v->maxx) {
  552.           if (v->flags & FWRAP) {
  553.               normal_putch(v, '\n');
  554. !             goto col0;
  555.           } else {
  556.               v->cx = v->maxx;
  557. ***************
  558. *** 1069,1081 ****
  559.           }
  560.       } else {
  561. - #if 0
  562. -         v->cursaddr = PLACE(v, v->cx, v->cy);
  563. - #else
  564.           v->cursaddr++;
  565. !         if ( (v->cx & 1) == 0 && v->planes > 1) { /* new word */
  566. !             short skipwords = v->planes - 1;
  567. !             v->cursaddr += skipwords+skipwords;
  568. !         }
  569. ! #endif
  570.       }
  571.   }
  572. --- 1137,1143 ----
  573.           }
  574.       } else {
  575.           v->cursaddr++;
  576. !         if ((i = v->planes-1) && !(v->cx & 1))    /* new word */
  577. !             v->cursaddr += i + i;
  578.       }
  579.   }
  580.